home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 7 / Night Owl Shareware (NOPV7)(Night Owl Publisher Inc.)(1992).bin / 038a / bash1_12.arj / BASH1-12.TAR / bash-1.12 / builtins / mkbuiltins.c < prev    next >
C/C++ Source or Header  |  1991-11-05  |  31KB  |  1,209 lines
  1. /* mkbuiltins.c - Create builtins.c, builtext.h, and builtdoc.c from
  2.    a single source file called builtins.def. */
  3.  
  4. /* Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  21.  
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include <sys/file.h>
  25. #include <sys/stat.h>
  26. #include "../filecntl.h"
  27.  
  28. #define DOCFILE "builtins.texi"
  29.  
  30. static char *xmalloc (), *xrealloc ();
  31. #define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
  32. #define whitespace(c) (((c) == ' ') || ((c) == '\t'))
  33.  
  34. /* If this stream descriptor is non-zero, then write
  35.    texinfo documentation to it. */
  36. FILE *documentation_file = (FILE *)NULL;
  37.  
  38. /* Non-zero means to only produce documentation. */
  39. int only_documentation = 0;
  40.  
  41. /* Non-zero means to not do any productions. */
  42. int inhibit_production = 0;
  43.  
  44. /* The name of a directory to precede the filename when reporting
  45.    errors. */
  46. char *error_directory = (char *)NULL;
  47.  
  48. /* The name of the structure file. */
  49. char *struct_filename = (char *)NULL;
  50.  
  51. /* The name of the external declaration file. */
  52. char *extern_filename = (char *)NULL;
  53.  
  54. /* Here is a structure for manipulating arrays of data. */
  55. typedef struct {
  56.   int size;        /* Number of slots allocated to array. */
  57.   int index;        /* Current location in array. */
  58.   int width;        /* Size of each element. */
  59.   int growth_rate;    /* How fast to grow. */
  60.   char **array;        /* The array itself. */
  61. } ARRAY;
  62.  
  63. /* Here is a structure defining a single BUILTIN. */
  64. typedef struct {
  65.   char *name;        /* The name of this builtin. */
  66.   char *function;    /* The name of the function to call. */
  67.   char *shortdoc;    /* The short documentation for this builtin. */
  68.   char *docname;    /* Possible name for documentation string. */
  69.   ARRAY *longdoc;    /* The long documentation for this builtin. */
  70.   ARRAY *dependencies;    /* Null terminated array of #define names. */
  71. } BUILTIN_DESC;
  72.  
  73. /* Here is a structure which defines a DEF file. */
  74. typedef struct {
  75.   char *filename;    /* The name of the input def file. */
  76.   ARRAY *lines;        /* The contents of the file. */
  77.   int line_number;    /* The current line number. */
  78.   char *production;    /* The name of the production file. */
  79.   FILE *output;        /* Open file stream for PRODUCTION. */
  80.   ARRAY *builtins;    /* Null terminated array of BUILTIN_DESC *. */
  81. } DEF_FILE;
  82.  
  83. /* The array of all builtins encountered during execution of this code. */
  84. ARRAY *saved_builtins = (ARRAY *)NULL;
  85.  
  86.  
  87. /* For each file mentioned on the command line, process it and
  88.    write the information to STRUCTFILE and EXTERNFILE, while
  89.    creating the production file if neccessary. */
  90. main (argc, argv)
  91.      int argc;
  92.      char **argv;
  93. {
  94.   int arg_index = 1;
  95.   FILE *structfile, *externfile;
  96.   char *documentation_filename, *temp_struct_filename;
  97.  
  98.   structfile = externfile = (FILE *)NULL;
  99.   documentation_filename = DOCFILE;
  100.   temp_struct_filename = (char *)NULL;
  101.  
  102.   while (arg_index < argc && argv[arg_index][0] == '-')
  103.     {
  104.       char *arg = argv[arg_index++];
  105.  
  106.       if (strcmp (arg, "-externfile") == 0)
  107.     extern_filename = argv[arg_index++];
  108.       else if (strcmp (arg, "-structfile") == 0)
  109.     struct_filename = argv[arg_index++];
  110.       else if (strcmp (arg, "-noproduction") == 0)
  111.     inhibit_production = 1;
  112.       else if (strcmp (arg, "-document") == 0)
  113.     documentation_file = fopen (documentation_filename, "w");
  114.       else if (strcmp (arg, "-D") == 0)
  115.     {
  116.       int len;
  117.  
  118.       if (error_directory)
  119.         free (error_directory);
  120.  
  121.       error_directory = (char *)xmalloc (2 + strlen (argv[arg_index]));
  122.       strcpy (error_directory, argv[arg_index]);
  123.       len = strlen (error_directory);
  124.  
  125.       if (len && error_directory[len - 1] != '/')
  126.         strcat (error_directory, "/");
  127.  
  128.       arg_index++;
  129.     }
  130.       else if (strcmp (arg, "-documentonly") == 0)
  131.     {
  132.       only_documentation = 1;
  133.       documentation_file = fopen (documentation_filename, "w");
  134.     }
  135.       else
  136.     {
  137.       fprintf (stderr, "%s: Unknown flag %s.\n", argv[0], arg);
  138.       exit (2);
  139.     }
  140.     }
  141.  
  142.   /* If there are no files to process, just quit now. */
  143.   if (arg_index == argc)
  144.     exit (0);
  145.  
  146.   if (!only_documentation)
  147.     {
  148.       /* Open the files. */
  149.       if (struct_filename)
  150.     {
  151.       temp_struct_filename = (char *)xmalloc (15);
  152.       sprintf (temp_struct_filename, "mk-%d", (int) getpid ());
  153.       structfile = fopen (temp_struct_filename, "w");
  154.  
  155.       if (!structfile)
  156.         file_error (temp_struct_filename);
  157.     }
  158.  
  159.       if (extern_filename)
  160.     {
  161.       externfile = fopen (extern_filename, "w");
  162.  
  163.       if (!externfile)
  164.         file_error (extern_filename);
  165.     }
  166.  
  167.       /* Write out the headers. */
  168.       write_file_headers (structfile, externfile);
  169.     }
  170.  
  171.   if (documentation_file)
  172.     {
  173.       fprintf (documentation_file, "@c Table of builtins created with %s.\n",
  174.            argv[0]);
  175.       fprintf (documentation_file, "@ftable @asis\n");
  176.     }
  177.  
  178.   /* Process the .def files. */
  179.   while (arg_index < argc)
  180.     {
  181.       register char *arg;
  182.  
  183.       arg = argv[arg_index++];
  184.  
  185.       extract_info (arg, structfile, externfile);
  186.     }
  187.  
  188.   /* Close the files. */
  189.   if (!only_documentation)
  190.     {
  191.       /* Write the footers. */
  192.       write_file_footers (structfile, externfile);
  193.  
  194.       if (structfile)
  195.     {
  196.       write_longdocs (structfile, saved_builtins);
  197.       fclose (structfile);
  198.       link (temp_struct_filename, struct_filename);
  199.       unlink (temp_struct_filename);
  200.     }
  201.  
  202.       if (externfile)
  203.     fclose (externfile);
  204.     }
  205.  
  206.   if (documentation_file)
  207.     {
  208.       fprintf (documentation_file, "@end ftable\n");
  209.       fclose (documentation_file);
  210.     }
  211.  
  212.   exit (0);
  213. }
  214.  
  215. /* **************************************************************** */
  216. /*                                    */
  217. /*          Array Functions and Manipulators            */
  218. /*                                    */
  219. /* **************************************************************** */
  220.  
  221. /* Make a new array, and return a pointer to it.  The array will
  222.    contain elements of size WIDTH, and is initialized to no elements. */
  223. ARRAY *
  224. array_create (width)
  225.      int width;
  226. {
  227.   ARRAY *array;
  228.  
  229.   array = (ARRAY *)xmalloc (sizeof (ARRAY));
  230.   array->size = 0;
  231.   array->index = 0;
  232.   array->width = width;
  233.  
  234.   /* Default to increasing size in units of 20. */
  235.   array->growth_rate = 20;
  236.  
  237.   array->array = (char **)NULL;
  238.  
  239.   return (array);
  240. }
  241.  
  242. /* Copy the array of strings in ARRAY. */
  243. ARRAY *
  244. copy_string_array (array)
  245.      ARRAY *array;
  246. {
  247.   register int i;
  248.   ARRAY *copy;
  249.  
  250.   if (!array)
  251.     return (ARRAY *)NULL;
  252.  
  253.   copy = array_create (sizeof (char *));
  254.  
  255.   copy->size = array->size;
  256.   copy->index = array->index;
  257.   copy->width = array->width;
  258.  
  259.   copy->array = (char **)xmalloc ((1 + array->index) * sizeof (char *));
  260.   
  261.   for (i = 0; i < array->index; i++)
  262.     copy->array[i] = savestring (array->array[i]);
  263.  
  264.   copy->array[i] = (char *)NULL;
  265.  
  266.   return (copy);
  267. }
  268.  
  269. /* Add ELEMENT to ARRAY, growing the array if neccessary. */
  270. array_add (element, array)
  271.      char *element;
  272.      ARRAY *array;
  273. {
  274.   if (array->index + 2 > array->size)
  275.     array->array = (char **)xrealloc
  276.       (array->array, (array->size += array->growth_rate) * array->width);
  277.  
  278. #if defined (HAVE_BCOPY)
  279.   bcopy (&element, &(array->array[array->index]), array->width);
  280.   array->index++;
  281.   bzero (&(array->array[array->index]), array->width);
  282. #else
  283.   array->array[array->index++] = element;
  284.   array->array[array->index] = (char *)NULL;
  285. #endif /* !HAVE_BCOPY */
  286. }
  287.  
  288. /* Free an allocated array and data pointer. */
  289. array_free (array)
  290.      ARRAY *array;
  291. {
  292.   if (array->array)
  293.     free (array->array);
  294.  
  295.   free (array);
  296. }
  297.  
  298. /* **************************************************************** */
  299. /*                                    */
  300. /*               Processing a DEF File                */
  301. /*                                    */
  302. /* **************************************************************** */
  303.  
  304. /* The definition of a function. */
  305. typedef int Function ();
  306.  
  307. /* Structure handles processor directives. */
  308. typedef struct {
  309.   char *directive;
  310.   Function *function;
  311. } HANDLER_ENTRY;
  312.  
  313. extern int
  314.   builtin_handler (), function_handler (), short_doc_handler (),
  315.   comment_handler (), depends_on_handler (), produces_handler (),
  316.   end_handler (), docname_handler ();
  317.  
  318. HANDLER_ENTRY handlers[] = {
  319.   { "BUILTIN", builtin_handler },
  320.   { "DOCNAME", docname_handler },
  321.   { "FUNCTION", function_handler },
  322.   { "SHORT_DOC", short_doc_handler },
  323.   { "$", comment_handler },
  324.   { "COMMENT", comment_handler },
  325.   { "DEPENDS_ON", depends_on_handler },
  326.   { "PRODUCES", produces_handler },
  327.   { "END", end_handler },
  328.   { (char *)NULL, (Function *)NULL }
  329. };
  330.  
  331. /* Return the entry in the table of handlers for NAME. */
  332. HANDLER_ENTRY *
  333. find_directive (directive)
  334.      char *directive;
  335. {
  336.   register int i;
  337.  
  338.   for (i = 0; handlers[i].directive; i++)
  339.     if (strcmp (handlers[i].directive, directive) == 0)
  340.       return (&handlers[i]);
  341.  
  342.   return ((HANDLER_ENTRY *)NULL);
  343. }
  344.  
  345. /* Non-zero indicates that a $BUILTIN has been seen, but not
  346.    the corresponding $END. */
  347. static int building_builtin = 0;
  348.  
  349. /* Non-zero means to output cpp line and file information before
  350.    printing the current line to the production file. */
  351. int output_cpp_line_info = 0;
  352.  
  353. /* The main function of this program.  Read FILENAME and act on what is
  354.    found.  Lines not starting with a dollar sign are copied to the
  355.    $PRODUCES target, if one is present.  Lines starting with a dollar sign
  356.    are directives to this program, specifying the name of the builtin, the
  357.    function to call, the short documentation and the long documentation
  358.    strings.  FILENAME can contain multiple $BUILTINs, but only one $PRODUCES
  359.    target.  After the file has been processed, write out the names of
  360.    builtins found in each $BUILTIN.  Plain text found before the $PRODUCES
  361.    is ignored, as is "$$ comment text". */
  362. extract_info (filename, structfile, externfile)
  363.      char *filename;
  364.      FILE *structfile, *externfile;
  365. {
  366.   register int i;
  367.   DEF_FILE *defs;
  368.   struct stat finfo;
  369.   char *buffer, *line;
  370.   int fd;
  371.  
  372.   if (stat (filename, &finfo) == -1)
  373.     file_error (filename);
  374.  
  375.   fd = open (filename, O_RDONLY, 0666);
  376.  
  377.   if (fd == -1)
  378.     file_error (filename);
  379.  
  380.   buffer = xmalloc (1 + finfo.st_size);
  381.  
  382.   if (read (fd, buffer, finfo.st_size) != finfo.st_size)
  383.     file_error (filename);
  384.  
  385.   close (fd);
  386.  
  387.   /* Create and fill in the initial structure describing this file. */
  388.   defs = (DEF_FILE *)xmalloc (sizeof (DEF_FILE));
  389.   defs->filename = filename;
  390.   defs->lines = array_create (sizeof (char *));
  391.   defs->line_number = 0;
  392.   defs->production = (char *)NULL;
  393.   defs->output = (FILE *)NULL;
  394.   defs->builtins = (ARRAY *)NULL;
  395.  
  396.   /* Build the array of lines. */
  397.   i = 0;
  398.   while (i < finfo.st_size)
  399.     {
  400.       array_add (&buffer[i], defs->lines);
  401.  
  402.       while (buffer[i] != '\n' && i < finfo.st_size)
  403.     i++;
  404.       buffer[i++] = '\0';
  405.     }
  406.  
  407.   /* Begin processing the input file.  We don't write any output
  408.      until we have a file to write output to. */
  409.   output_cpp_line_info = 1;
  410.  
  411.   /* Process each line in the array. */
  412.   for (i = 0; line = defs->lines->array[i]; i++)
  413.     {
  414.       defs->line_number = i;
  415.  
  416.       if (*line == '$')
  417.     {
  418.       register int j;
  419.       char *directive;
  420.       HANDLER_ENTRY *handler;
  421.  
  422.       /* Isolate the directive. */
  423.       for (j = 0; line[j] && !whitespace (line[j]); j++);
  424.  
  425.       directive = xmalloc (j);
  426.       strncpy (directive, line + 1, j - 1);
  427.       directive[j -1] = '\0';
  428.  
  429.       /* Get the function handler and call it. */
  430.       handler = find_directive (directive);
  431.  
  432.       if (!handler)
  433.         {
  434.           line_error (defs, "Unknown directive `%s'", directive);
  435.           continue;
  436.         }
  437.       else
  438.         {
  439.           /* Advance to the first non-whitespace character. */
  440.           while (whitespace (line[j]))
  441.         j++;
  442.  
  443.           /* Call the directive handler with the FILE, and ARGS. */
  444.           (*(handler->function)) (directive, defs, line + j);
  445.         }
  446.     }
  447.       else
  448.     {
  449.       if (building_builtin)
  450.         add_documentation (defs, line);
  451.       else if (defs->output)
  452.         {
  453.           if (output_cpp_line_info)
  454.         {
  455.           fprintf (defs->output, "#line %d \"%s%s\"\n",
  456.                defs->line_number + 1,
  457.                error_directory, defs->filename);
  458.           output_cpp_line_info = 0;
  459.         }
  460.  
  461.           fprintf (defs->output, "%s\n", line);
  462.         }
  463.     }
  464.     }
  465.  
  466.   /* Close the production file. */
  467.   if (defs->output)
  468.     fclose (defs->output);
  469.  
  470.   /* The file has been processed.  Write the accumulated builtins to
  471.      the builtins.c file, and write the extern definitions to the
  472.      builtext.h file. */
  473.   write_builtins (defs, structfile, externfile);
  474.  
  475.   free (buffer);
  476.   free_defs (defs);
  477. }
  478.  
  479. #define free_safely(x) if (x) free (x)
  480.  
  481. /* Free all of the memory allocated to a DEF_FILE. */
  482. free_defs (defs)
  483.      DEF_FILE *defs;
  484. {
  485.   register int i, j;
  486.   register BUILTIN_DESC *builtin;
  487.  
  488.   if (defs->production)
  489.     free (defs->production);
  490.  
  491.   if (defs->builtins)
  492.     {
  493.       for (i = 0; builtin = (BUILTIN_DESC *)defs->builtins->array[i]; i++)
  494.     {
  495.       free_safely (builtin->name);
  496.       free_safely (builtin->function);
  497.       free_safely (builtin->shortdoc);
  498.  
  499.       if (builtin->dependencies)
  500.         {
  501.           for (j = 0; builtin->dependencies->array[j]; j++)
  502.         free (builtin->dependencies->array[j]);
  503.  
  504.           array_free (builtin->dependencies);
  505.         }
  506.  
  507.       if (builtin->longdoc)
  508.         array_free (builtin->longdoc);
  509.     }
  510.       array_free (defs->builtins);
  511.     }
  512.   free (defs);
  513. }
  514.  
  515. /* **************************************************************** */
  516. /*                                    */
  517. /*             The Handler Functions Themselves            */
  518. /*                                    */
  519. /* **************************************************************** */
  520.  
  521. /* Strip surrounding whitespace from STRING, and
  522.    return a pointer to the start of it. */
  523. char *
  524. strip_whitespace (string)
  525.      char *string;
  526. {
  527.   while (whitespace (*string))
  528.       string++;
  529.  
  530.   remove_trailing_whitespace (string);
  531.   return (string);
  532. }
  533.  
  534. /* Remove only the trailing whitespace from STRING. */
  535. remove_trailing_whitespace (string)
  536.      char *string;
  537. {
  538.   register int i;
  539.  
  540.   i = strlen (string) - 1;
  541.  
  542.   while (i > 0 && whitespace (string[i]))
  543.     i--;
  544.  
  545.   string[++i] = '\0';
  546. }
  547.  
  548. /* Ensure that there is a argument in STRING and return it.
  549.    FOR_WHOM is the name of the directive which needs the argument.
  550.    DEFS is the DEF_FILE in which the directive is found.
  551.    If there is no argument, produce an error. */
  552. char *
  553. get_arg (for_whom, defs, string)
  554.      char *for_whom, *string;
  555.      DEF_FILE *defs;
  556. {
  557.   char *new;
  558.  
  559.   new = strip_whitespace (string);
  560.  
  561.   if (!*new)
  562.     line_error (defs, "%s requires an argument", for_whom);
  563.  
  564.   return (savestring (new));
  565. }
  566.  
  567. /* Error if not building a builtin. */
  568. must_be_building (directive, defs)
  569.      char *directive;
  570.      DEF_FILE *defs;
  571. {
  572.   if (!building_builtin)
  573.     line_error (defs, "%s must be inside of a $BUILTIN block", directive);
  574. }
  575.  
  576. /* Return the current builtin. */
  577. BUILTIN_DESC *
  578. current_builtin (directive, defs)
  579.      char *directive;
  580.      DEF_FILE *defs;
  581. {
  582.   must_be_building (directive, defs);
  583.   return ((BUILTIN_DESC *)defs->builtins->array[defs->builtins->index - 1]);
  584. }
  585.  
  586. /* Add LINE to the long documentation for the current builtin.
  587.    Ignore blank lines until the first non-blank line has been seen. */
  588. add_documentation (defs, line)
  589.      DEF_FILE *defs;
  590.      char *line;
  591. {
  592.   register BUILTIN_DESC *builtin;
  593.  
  594.   builtin = current_builtin ("(implied LONGDOC)", defs);
  595.  
  596.   remove_trailing_whitespace (line);
  597.  
  598.   if (!*line && !builtin->longdoc)
  599.     return;
  600.  
  601.   if (!builtin->longdoc)
  602.     builtin->longdoc = array_create (sizeof (char *));
  603.  
  604.   array_add (line, builtin->longdoc);
  605. }
  606.  
  607. /* How to handle the $BUILTIN directive. */
  608. int
  609. builtin_handler (self, defs, arg)
  610.      char *self, *arg;
  611.      DEF_FILE *defs;
  612. {
  613.   /* If we are already building a builtin, we cannot start a new one. */
  614.   if (building_builtin)
  615.     return (line_error (defs, "%s found before $END", self));
  616.  
  617.   output_cpp_line_info++;
  618.  
  619.   /* Get the name of this builtin, and stick it in the array. */
  620.   {
  621.     BUILTIN_DESC *new;
  622.     char *name;
  623.  
  624.     name = get_arg (self, defs, arg);
  625.  
  626.     /* If this is the first builtin, create the array to hold them. */
  627.     if (!defs->builtins)
  628.       defs->builtins = array_create (sizeof (BUILTIN_DESC *));
  629.  
  630.     new = (BUILTIN_DESC *)xmalloc (sizeof (BUILTIN_DESC));
  631.     new->name = name;
  632.     new->function = (char *)NULL;
  633.     new->shortdoc = (char *)NULL;
  634.     new->docname = (char *)NULL;
  635.     new->longdoc = (ARRAY *)NULL;
  636.     new->dependencies = (ARRAY *)NULL;
  637.  
  638.     array_add ((char *)new, defs->builtins);
  639.     building_builtin = 1;
  640.   }
  641.   return (0);
  642. }
  643.  
  644. /* How to handle the $FUNCTION directive. */
  645. int
  646. function_handler (self, defs, arg)
  647.      char *self, *arg;
  648.      DEF_FILE *defs;
  649. {
  650.   register BUILTIN_DESC *builtin;
  651.  
  652.   builtin = current_builtin (self, defs);
  653.  
  654.   if (builtin->function)
  655.     line_error (defs, "%s already has a function (%s)",
  656.         builtin->name, builtin->function);
  657.   else
  658.     builtin->function = get_arg (self, defs, arg);
  659.  
  660.   return (0);
  661. }
  662.  
  663. /* How to handle the $DOCNAME directive. */
  664. int
  665. docname_handler (self, defs, arg)
  666.      char *self, *arg;
  667.      DEF_FILE *defs;
  668. {
  669.   register BUILTIN_DESC *builtin;
  670.  
  671.   builtin = current_builtin (self, defs);
  672.  
  673.   if (builtin->docname)
  674.     line_error (defs, "%s already had a docname (%s)",
  675.         builtin->name, builtin->docname);
  676.   else
  677.     builtin->docname = get_arg (self, defs, arg);
  678.  
  679.   return (0);
  680. }
  681.  
  682. /* How to handle the $SHORT_DOC directive. */
  683. short_doc_handler (self, defs, arg)
  684.      char *self, *arg;
  685.      DEF_FILE *defs;
  686. {
  687.   register BUILTIN_DESC *builtin;
  688.  
  689.   builtin = current_builtin (self, defs);
  690.  
  691.   if (builtin->shortdoc)
  692.     line_error (defs, "%s already has short documentation (%s)",
  693.         builtin->name, builtin->shortdoc);
  694.   else
  695.     builtin->shortdoc = get_arg (self, defs, arg);
  696.  
  697.   return (0);
  698. }
  699.  
  700. /* How to handle the $COMMENT directive. */
  701. comment_handler (self, defs)
  702.      char *self;
  703.      DEF_FILE *defs;
  704. {
  705. }
  706.  
  707. /* How to handle the $DEPENDS_ON directive. */
  708. depends_on_handler (self, defs, arg)
  709.      char *self, *arg;
  710.      DEF_FILE *defs;
  711. {
  712.   register BUILTIN_DESC *builtin;
  713.   char *dependent;
  714.  
  715.   builtin = current_builtin (self, defs);
  716.   dependent = get_arg (self, defs, arg);
  717.  
  718.   if (!builtin->dependencies)
  719.     builtin->dependencies = array_create (sizeof (char *));
  720.  
  721.   array_add (dependent, builtin->dependencies);
  722.  
  723.   return (0);
  724. }
  725.  
  726. /* How to handle the $PRODUCES directive. */
  727. produces_handler (self, defs, arg)
  728.      char *self, *arg;
  729.      DEF_FILE *defs;
  730. {
  731.   /* If just hacking documentation, don't change any of the production
  732.      files. */
  733.   if (only_documentation)
  734.     return (0);
  735.  
  736.   output_cpp_line_info++;
  737.  
  738.   if (defs->production)
  739.     line_error (defs, "%s already has a %s definition", defs->filename, self);
  740.   else
  741.     {
  742.       defs->production = get_arg (self, defs, arg);
  743.  
  744.       if (inhibit_production)
  745.     return (0);
  746.  
  747.       defs->output = fopen (defs->production, "w");
  748.  
  749.       if (!defs->output)
  750.     file_error (defs->production);
  751.  
  752.       fprintf (defs->output, "/* %s, created from %s. */\n",
  753.            defs->production, defs->filename);
  754.     }
  755.   return (0);
  756. }
  757.  
  758. /* How to handle the $END directive. */
  759. end_handler (self, defs, arg)
  760.      char *self, *arg;
  761.      DEF_FILE *defs;
  762. {
  763.   must_be_building (self, defs);
  764.   building_builtin = 0;
  765. }
  766.  
  767. /* **************************************************************** */
  768. /*                                    */
  769. /*            Error Handling Functions                */
  770. /*                                    */
  771. /* **************************************************************** */
  772.  
  773. /* Produce an error for DEFS with FORMAT and ARGS. */
  774. line_error (defs, format, arg1, arg2)
  775.      DEF_FILE *defs;
  776.      char *format, *arg1, *arg2;
  777. {
  778.   fprintf (stderr, "%s%s:%d:",
  779.        error_directory, defs->filename, defs->line_number + 1);
  780.   fprintf (stderr, format, arg1, arg2);
  781.   fprintf (stderr, "\n");
  782.   fflush (stderr);
  783. }
  784.  
  785. /* Print error message for FILENAME. */
  786. file_error (filename)
  787.      char *filename;
  788. {
  789.   perror (filename);
  790.   exit (2);
  791. }
  792.  
  793. /* **************************************************************** */
  794. /*                                    */
  795. /*            xmalloc and xrealloc ()                     */
  796. /*                                    */
  797. /* **************************************************************** */
  798.  
  799. static void memory_error_and_abort ();
  800.  
  801. static char *
  802. xmalloc (bytes)
  803.      int bytes;
  804. {
  805.   char *temp = (char *)malloc (bytes);
  806.  
  807.   if (!temp)
  808.     memory_error_and_abort ();
  809.   return (temp);
  810. }
  811.  
  812. static char *
  813. xrealloc (pointer, bytes)
  814.      char *pointer;
  815.      int bytes;
  816. {
  817.   char *temp;
  818.  
  819.   if (!pointer)
  820.     temp = (char *)malloc (bytes);
  821.   else
  822.     temp = (char *)realloc (pointer, bytes);
  823.  
  824.   if (!temp)
  825.     memory_error_and_abort ();
  826.  
  827.   return (temp);
  828. }
  829.  
  830. static void
  831. memory_error_and_abort ()
  832. {
  833.   fprintf (stderr, "mkbuiltins: Out of virtual memory!\n");
  834.   abort ();
  835. }
  836.  
  837. /* **************************************************************** */
  838. /*                                    */
  839. /*          Creating the Struct and Extern Files            */
  840. /*                                    */
  841. /* **************************************************************** */
  842.  
  843. /* Return a pointer to a newly allocated builtin which is
  844.    an exact copy of BUILTIN. */
  845. BUILTIN_DESC *
  846. copy_builtin (builtin)
  847.      BUILTIN_DESC *builtin;
  848. {
  849.   BUILTIN_DESC *new;
  850.  
  851.   new = (BUILTIN_DESC *)xmalloc (sizeof (BUILTIN_DESC));
  852.  
  853.   new->name         = savestring (builtin->name);
  854.   new->shortdoc     = savestring (builtin->shortdoc);
  855.   new->longdoc      = copy_string_array (builtin->longdoc);
  856.   new->dependencies = copy_string_array (builtin->dependencies);
  857.  
  858.   new->function =
  859.     builtin->function ? savestring (builtin->function) : (char *)NULL;
  860.   new->docname =
  861.     builtin->docname  ? savestring (builtin->docname)  : (char *)NULL;
  862.  
  863.   return (new);
  864. }
  865.  
  866. /* How to save away a builtin. */
  867. save_builtin (builtin)
  868.      BUILTIN_DESC *builtin;
  869. {
  870.   BUILTIN_DESC *newbuiltin;
  871.  
  872.   newbuiltin = copy_builtin (builtin);
  873.  
  874.   /* If this is the first builtin to be saved, create the array
  875.      to hold it. */
  876.   if (!saved_builtins)
  877.       saved_builtins = array_create (sizeof (BUILTIN_DESC *));
  878.  
  879.   array_add ((char *)newbuiltin, saved_builtins);
  880. }
  881.  
  882. /* Flags that mean something to write_documentation (). */
  883. #define STRING_ARRAY 1
  884. #define TEXINFO 2
  885.  
  886. char *structfile_header[] = {
  887.   "/* builtins.c -- the built in shell commands. */",
  888.   "",
  889.   "/* This file is manufactured by ./mkbuiltins, and should not be",
  890.   "   edited by hand.  See the source to mkbuiltins for details. */",
  891.   "",
  892.   "/* Copyright (C) 1987, 1991 Free Software Foundation, Inc.",
  893.   "",
  894.   "   This file is part of GNU Bash, the Bourne Again SHell.",
  895.   "",
  896.   "   Bash is free software; you can redistribute it and/or modify it",
  897.   "   under the terms of the GNU General Public License as published by",
  898.   "   the Free Software Foundation; either version 1, or (at your option)",
  899.   "   any later version.",
  900.   "",
  901.   "   Bash is distributed in the hope that it will be useful, but WITHOUT",
  902.   "   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY",
  903.   "   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public",
  904.   "   License for more details.",
  905.   "",
  906.   "   You should have received a copy of the GNU General Public License",
  907.   "   along with Bash; see the file COPYING.  If not, write to the Free",
  908.   "   Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */",
  909.   "",
  910.   "/* The list of shell builtins.  Each element is name, function, enabled-p,",
  911.   "   long-doc, short-doc.  The long-doc field contains a pointer to an array",
  912.   "   of help lines.  The function takes a WORD_LIST *; the first word in the",
  913.   "   list is the first arg to the command.  The list has already had word",
  914.   "   expansion performed.",
  915.   "",
  916.   "   Functions which need to look at only the simple commands (e.g.",
  917.   "   the enable_builtin ()), should ignore entries where",
  918.   "   (array[i].function == (Function *)NULL).  Such entries are for",
  919.   "   the list of shell reserved control structures, like `if' and `while'.",
  920.   "   The end of the list is denoted with a NULL name field. */",
  921.   "",
  922.   "#include \"../builtins.h\"",
  923.   (char *)NULL
  924.   };
  925.  
  926. char *structfile_footer[] = {
  927.   "  { (char *)0x0, (Function *)0x0, 0, (char **)0x0, (char *)0x0 }",
  928.   "};",
  929.   "",
  930.   "int num_shell_builtins =",
  931.   "\tsizeof (shell_builtins) / sizeof (struct builtin) - 1;",
  932.   (char *)NULL
  933. };
  934.  
  935. /* Write out any neccessary opening information for
  936.    STRUCTFILE and EXTERNFILE. */
  937. write_file_headers (structfile, externfile)
  938.      FILE *structfile, *externfile;
  939. {
  940.   register int i;
  941.  
  942.   if (structfile)
  943.     {
  944.       for (i = 0; structfile_header[i]; i++)
  945.     fprintf (structfile, "%s\n", structfile_header[i]);
  946.  
  947.       fprintf (structfile, "#include \"%s\"\n",
  948.            extern_filename ? extern_filename : "builtext.h");
  949.  
  950.       fprintf (structfile, "\nstruct builtin shell_builtins[] = {\n");
  951.     }
  952.  
  953.   if (externfile)
  954.     fprintf (externfile,
  955.          "/* %s - The list of builtins found in libbuiltins.a. */\n",
  956.          extern_filename ? extern_filename : "builtext.h");
  957. }
  958.  
  959. /* Write out any necessary closing information for
  960.    STRUCTFILE and EXTERNFILE. */
  961. write_file_footers (structfile, externfile)
  962.      FILE *structfile, *externfile;
  963. {
  964.   register int i;
  965.  
  966.   /* Write out the footers. */
  967.   if (structfile)
  968.     {
  969.       for (i = 0; structfile_footer[i]; i++)
  970.     fprintf (structfile, "%s\n", structfile_footer[i]);
  971.     }
  972. }
  973.  
  974. /* Write out the information accumulated in DEFS to
  975.    STRUCTFILE and EXTERNFILE. */
  976. write_builtins (defs, structfile, externfile)
  977.      DEF_FILE *defs;
  978.      FILE *structfile, *externfile;
  979. {
  980.   register int i;
  981.  
  982.   /* Write out the information. */
  983.   if (defs->builtins)
  984.     {
  985.       register BUILTIN_DESC *builtin;
  986.  
  987.       for (i = 0; i < defs->builtins->index; i++)
  988.     {
  989.       builtin = (BUILTIN_DESC *)defs->builtins->array[i];
  990.  
  991.       /* Write out any #ifdefs that may be there. */
  992.       if (!only_documentation)
  993.         {
  994.           if (builtin->dependencies)
  995.         {
  996.           if (builtin->function)
  997.             write_ifdefs (externfile, builtin->dependencies->array);
  998.           write_ifdefs (structfile, builtin->dependencies->array);
  999.         }
  1000.  
  1001.           /* Write the extern definition. */
  1002.           if (externfile)
  1003.         {
  1004.           if (builtin->function)
  1005.             fprintf (externfile, "extern int %s ();\n",
  1006.                  builtin->function);
  1007.  
  1008.           fprintf (externfile, "extern char *%s_doc[];\n",
  1009.                builtin->docname ?builtin->docname : builtin->name);
  1010.         }
  1011.  
  1012.           /* Write the structure definition. */
  1013.           if (structfile)
  1014.         {
  1015.           fprintf (structfile, "  { \"%s\", ", builtin->name);
  1016.  
  1017.           if (builtin->function)
  1018.             fprintf (structfile, "%s, ", builtin->function);
  1019.           else
  1020.             fprintf (structfile, "(Function *)0x0, ");
  1021.  
  1022.           fprintf (structfile, "1, %s_doc,\n",
  1023.                builtin->docname ?builtin->docname : builtin->name);
  1024.  
  1025.           fprintf
  1026.             (structfile, "     \"%s\" },\n",
  1027.              builtin->shortdoc ? builtin->shortdoc : builtin->name);
  1028.  
  1029.           /* Save away this builtin for later writing of the
  1030.              long documentation strings. */
  1031.           save_builtin (builtin);
  1032.         }
  1033.  
  1034.           /* Write out the matching #endif, if neccessary. */
  1035.           if (builtin->dependencies)
  1036.         {
  1037.           if (externfile)
  1038.             write_endifs (externfile, builtin->dependencies->array);
  1039.  
  1040.           if (structfile)
  1041.             write_endifs (structfile, builtin->dependencies->array);
  1042.         }
  1043.         }
  1044.  
  1045.       if (documentation_file)
  1046.         {
  1047.           fprintf (documentation_file, "@item %s\n", builtin->name);
  1048.           write_documentation
  1049.         (documentation_file, builtin->longdoc->array, 0, TEXINFO);
  1050.         }
  1051.     }
  1052.     }
  1053. }
  1054.  
  1055. /* Write out the long documentation strings in BUILTINS to STREAM. */
  1056. write_longdocs (stream, builtins)
  1057.      FILE *stream;
  1058.      ARRAY *builtins;
  1059. {
  1060.   register int i;
  1061.   register BUILTIN_DESC *builtin;
  1062.  
  1063.   for (i = 0; i < builtins->index; i++)
  1064.     {
  1065.       builtin = (BUILTIN_DESC *)builtins->array[i];
  1066.  
  1067.       if (builtin->dependencies)
  1068.     write_ifdefs (stream, builtin->dependencies->array);
  1069.  
  1070.       /* Write the long documentation strings. */
  1071.       fprintf (stream, "char *%s_doc[] =",
  1072.            builtin->docname ? builtin->docname : builtin->name);
  1073.       write_documentation (stream, builtin->longdoc->array, 0, STRING_ARRAY);
  1074.  
  1075.       if (builtin->dependencies)
  1076.     write_endifs (stream, builtin->dependencies->array);
  1077.  
  1078.     }
  1079. }
  1080.  
  1081. /* Write an #ifdef string saying what needs to be defined (or not defined)
  1082.    in order to allow compilation of the code that will follow.
  1083.    STREAM is the stream to write the information to,
  1084.    DEFINES is a null terminated array of define names.
  1085.    If a define is preceded by an `!', then the sense of the test is
  1086.    reversed. */
  1087. write_ifdefs (stream, defines)
  1088.      FILE *stream;
  1089.      char **defines;
  1090. {
  1091.   register int i;
  1092.  
  1093.   if (!stream)
  1094.     return;
  1095.  
  1096.   fprintf (stream, "#if ");
  1097.  
  1098.   for (i = 0; defines[i]; i++)
  1099.     {
  1100.       char *def = defines[i];
  1101.  
  1102.       if (*def == '!')
  1103.     fprintf (stream, "!defined (%s)", def + 1);
  1104.       else
  1105.     fprintf (stream, "defined (%s)", def);
  1106.  
  1107.       if (defines[i + 1])
  1108.     fprintf (stream, " && ");
  1109.     }
  1110.   fprintf (stream, "\n");
  1111. }
  1112.  
  1113. /* Write an #endif string saying what defines controlled the compilation
  1114.    of the immediately preceding code.
  1115.    STREAM is the stream to write the information to.
  1116.    DEFINES is a null terminated array of define names. */
  1117. write_endifs (stream, defines)
  1118.      FILE *stream;
  1119.      char **defines;
  1120. {
  1121.   register int i;
  1122.  
  1123.   if (!stream)
  1124.     return;
  1125.  
  1126.   fprintf (stream, "#endif /* ");
  1127.  
  1128.   for (i = 0; defines[i]; i++)
  1129.     {
  1130.       fprintf (stream, "%s", defines[i]);
  1131.  
  1132.       if (defines[i + 1])
  1133.     fprintf (stream, " && ");
  1134.     }
  1135.  
  1136.   fprintf (stream, " */\n");
  1137. }
  1138.  
  1139. /* Write DOCUMENTAION to STREAM, perhaps surrounding it with double-quotes
  1140.    and quoting special characters in the string. */
  1141. write_documentation (stream, documentation, indentation, flags)
  1142.      FILE *stream;
  1143.      char **documentation;
  1144.      int indentation, flags;
  1145. {
  1146.   register int i, j;
  1147.   register char *line;
  1148.   int string_array = (flags & STRING_ARRAY); /* Mutually exclusive. */
  1149.   int texinfo = (flags & TEXINFO);
  1150.  
  1151.   if (!stream)
  1152.     return;
  1153.  
  1154.   if (string_array)
  1155.     fprintf (stream, " {\n");
  1156.  
  1157.   for (i = 0; line = documentation[i]; i++)
  1158.     {
  1159.       if (string_array)
  1160.     fprintf (stream, "  \"");
  1161.  
  1162.       if (indentation)
  1163.     for (j = 0; j < indentation; j++)
  1164.       fprintf (stream, " ");
  1165.  
  1166.       if (string_array)
  1167.     {
  1168.       for (j = 0; line[j]; j++)
  1169.         {
  1170.           switch (line[j])
  1171.         {
  1172.         case '\\':
  1173.         case '"':
  1174.           fprintf (stream, "\\%c", line[j]);
  1175.           break;
  1176.  
  1177.         default:
  1178.           fprintf (stream, "%c", line[j]);
  1179.         }
  1180.         }
  1181.  
  1182.       fprintf (stream, "\",\n");
  1183.     }
  1184.       else if (texinfo)
  1185.     {
  1186.       for (j = 0; line[j]; j++)
  1187.         {
  1188.           switch (line[j])
  1189.         {
  1190.         case '@':
  1191.         case '{':
  1192.         case '}':
  1193.           fprintf (stream, "@%c", line[j]);
  1194.           break;
  1195.  
  1196.         default:
  1197.           fprintf (stream, "%c", line[j]);
  1198.         }
  1199.         }
  1200.       fprintf (stream, "\n");
  1201.     }
  1202.       else
  1203.     fprintf (stream, "%s\n", line);
  1204.     }
  1205.  
  1206.   if (string_array)
  1207.     fprintf (stream, "  (char *)NULL\n};\n");
  1208. }
  1209.